home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / network.zip / NETWARE.ZIP / IPX.C < prev    next >
C/C++ Source or Header  |  1990-01-02  |  7KB  |  244 lines
  1.  
  2. /*
  3.  *  IPX.C -- helper routines for accessing IPX services
  4.  *  from Turbo C.
  5. */
  6.  
  7. #include <stdlib.h>
  8. #include <dos.h>
  9. #include <mem.h>
  10. #include <string.h>
  11. #include <ipx.h>
  12.  
  13. void far          (*ipx_spx)(void);
  14.  
  15. int     ipx_spx_installed(void)
  16.         {
  17.         union REGS      regs;
  18.         struct SREGS    sregs;
  19.  
  20.         regs.x.ax = 0x7a00;
  21.         int86x(0x2f, ®s, ®s, &sregs);
  22.         if (regs.h.al != 0xff) return -1;
  23.  
  24.         ipx_spx = MK_FP(sregs.es, regs.x.di);
  25.         _BX = 0x0010;
  26.         _AL = 0x00;
  27.         ipx_spx();
  28.         if (_AL == 0x00) return 0;
  29.  
  30.         return 1;
  31.         }
  32.  
  33. int     ipx_cancel_event(struct ECB *ecb_ptr)
  34.         {
  35.         _ES = FP_SEG( (void far *) ecb_ptr);
  36.         _SI = FP_OFF( (void far *) ecb_ptr);
  37.         _BX = 0x0006;
  38.         ipx_spx();
  39.         _AH = 0;
  40.         return _AX;
  41.         }
  42.  
  43. void    close_socket(unsigned int socket)
  44.         {
  45.         if (ipx_spx_installed() < 1) return;
  46.         _BX = 0x0001;
  47.         _DX = socket;
  48.         ipx_spx();
  49.         }
  50.  
  51. int     open_socket(unsigned int socket)
  52.         {
  53.         if (ipx_spx_installed() < 1) return -1;
  54.         _DX = socket;
  55.         _BX = 0x0000;
  56.         _AL = 0xFF;
  57.         ipx_spx();
  58.         _AH = 0;
  59.         return _AX;
  60.         }
  61.  
  62. int     get_local_target(unsigned char *dest_network,
  63.                          unsigned char *dest_node,
  64.                          unsigned int   dest_socket,
  65.                          unsigned char *bridge_address)
  66.         {
  67.         unsigned int    temp_ax;
  68.  
  69.         struct  {
  70.                 unsigned char   network_number [4];
  71.                 unsigned char   physical_node  [6];
  72.                 unsigned int    socket;
  73.                 } request_buffer;
  74.  
  75.         struct  {
  76.                 unsigned char   local_target [6];
  77.                 } reply_buffer;
  78.  
  79.         memcpy(request_buffer.network_number, dest_network, 4);
  80.         memcpy(request_buffer.physical_node, dest_node, 6);
  81.         request_buffer.socket = dest_socket;
  82.  
  83.         _ES = FP_SEG( (void far *) &request_buffer);
  84.         _SI = FP_OFF( (void far *) &request_buffer);
  85.         _DI = FP_OFF( (void far *) &reply_buffer);
  86.         _BX = 0x0002;
  87.         ipx_spx();
  88.         _AH = 0;
  89.         temp_ax = _AX;
  90.         memcpy(bridge_address, reply_buffer.local_target, 6);
  91.         return temp_ax;
  92.         }
  93.  
  94. void    let_ipx_breath(void)
  95.         {
  96.         _BX = 0x000A;
  97.         ipx_spx();
  98.         }
  99.  
  100. void    ipx_listen_for_packet(struct ECB *ecb_ptr)
  101.         {
  102.         _ES = FP_SEG( (void far *) ecb_ptr);
  103.         _SI = FP_OFF( (void far *) ecb_ptr);
  104.         _BX = 0x0004;
  105.         ipx_spx();
  106.         }
  107.  
  108. void    ipx_send_packet(struct ECB *ecb_ptr)
  109.         {
  110.         _ES = FP_SEG( (void far *) ecb_ptr);
  111.         _SI = FP_OFF( (void far *) ecb_ptr);
  112.         _BX = 0x0003;
  113.         ipx_spx();
  114.         }
  115.  
  116. int     get_internet_address(unsigned char connection_number,
  117.                             unsigned char *network_number,
  118.                             unsigned char *physical_node)
  119.         {
  120.         union REGS      regs;
  121.         struct SREGS    sregs;
  122.  
  123.         struct  {
  124.                 unsigned int    len;
  125.                 unsigned char   buffer_type;
  126.                 unsigned char   connection_number;
  127.                 } request_buffer;
  128.  
  129.         struct  {
  130.                 unsigned int    len;
  131.                 unsigned char   network_number [4];
  132.                 unsigned char   physical_node  [6];
  133.                 unsigned int    server_socket;
  134.                 } reply_buffer;
  135.  
  136.         regs.h.ah = 0xe3;
  137.         request_buffer.len = 2;
  138.         request_buffer.buffer_type = 0x13;
  139.         request_buffer.connection_number = connection_number;
  140.  
  141.         reply_buffer.len = 12;
  142.  
  143.         regs.x.si = FP_OFF( (void far *) &request_buffer);
  144.         sregs.ds  = FP_SEG( (void far *) &request_buffer);
  145.         regs.x.di = FP_OFF( (void far *) &reply_buffer);
  146.         sregs.es  = FP_SEG( (void far *) &reply_buffer);
  147.         int86x(0x21, ®s, ®s, &sregs);
  148.  
  149.         memcpy(network_number, reply_buffer.network_number, 4);
  150.         memcpy(physical_node,  reply_buffer.physical_node,  6);
  151.         regs.h.ah = 0;
  152.         return regs.x.ax;
  153.         }
  154.  
  155. unsigned int    get_1st_connection_num (char *who)
  156.         {
  157.         union REGS      regs;
  158.         struct SREGS    sregs;
  159.  
  160.         struct  {
  161.                 unsigned int    len;
  162.                 unsigned char   buffer_type;
  163.                 unsigned int    object_type;
  164.                 unsigned char   name_len;
  165.                 unsigned char   name [47];
  166.                 } request_buffer;
  167.  
  168.         struct  {
  169.                 unsigned int    len;
  170.                 unsigned char   number_connections;
  171.                 unsigned char   connection_num [100];
  172.                 } reply_buffer;
  173.  
  174.         regs.h.ah = 0xe3;
  175.  
  176.         request_buffer.len = 51;
  177.         request_buffer.buffer_type = 0x15;
  178.         request_buffer.object_type = 0x0100;
  179.         request_buffer.name_len    = (unsigned char) strlen(who);
  180.         strcpy(request_buffer.name, who);
  181.  
  182.         reply_buffer.len = 101;
  183.  
  184.         regs.x.si = FP_OFF( (void far *) &request_buffer);
  185.         sregs.ds  = FP_SEG( (void far *) &request_buffer);
  186.         regs.x.di = FP_OFF( (void far *) &reply_buffer);
  187.         sregs.es  = FP_SEG( (void far *) &reply_buffer);
  188.  
  189.         int86x(0x21, ®s, ®s, &sregs);
  190.  
  191.         if (regs.h.al != 0) return 0;
  192.         if (reply_buffer.number_connections == 0) return 0;
  193.  
  194.         regs.h.ah = 0;
  195.         regs.h.al = reply_buffer.connection_num[0];
  196.         return regs.x.ax;
  197.         }
  198.  
  199. unsigned char get_connection_number(void)
  200.         {
  201.         _AH = 0xDC;
  202.         geninterrupt(0x21);
  203.         return _AL;
  204.         }
  205.  
  206. void    get_user_id(unsigned char connection_number,
  207.                     unsigned char *user_id)
  208.         {
  209.         union REGS      regs;
  210.         struct SREGS    sregs;
  211.  
  212.         struct  {
  213.                 unsigned int    len;
  214.                 unsigned char   buffer_type;
  215.                 unsigned char   connection_number;
  216.                 } request_buffer;
  217.  
  218.         struct  {
  219.                 unsigned int    len;
  220.                 unsigned char   object_id[4];
  221.                 unsigned char   object_type[2];
  222.                 char            object_name[48];
  223.                 char            login_time[7];
  224.                 } reply_buffer;
  225.  
  226.         regs.h.ah = 0xe3;
  227.         request_buffer.len = 2;
  228.         request_buffer.buffer_type = 0x16;
  229.         request_buffer.connection_number = connection_number;
  230.  
  231.         reply_buffer.len = 61;
  232.  
  233.         regs.x.si = FP_OFF( (void far *) &request_buffer);
  234.         sregs.ds  = FP_SEG( (void far *) &request_buffer);
  235.         regs.x.di = FP_OFF( (void far *) &reply_buffer);
  236.         sregs.es  = FP_SEG( (void far *) &reply_buffer);
  237.         int86x(0x21, ®s, ®s, &sregs);
  238.  
  239.         strncpy(user_id, reply_buffer.object_name, 48);
  240.         }
  241.  
  242.  
  243.  
  244.